﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SGT_DAL._STG_DALTableAdapters;
using SGT_DAL;
using System.Web;
using System.Web.Security;

namespace SGT_ON
{
    /// <summary>
    /// Modulo de seguridad
    /// Todo lo referido a seguridad esta en esta clase.
    /// </summary>
    public partial class ONEmpleado
    {
        public enum RolesDelSistema
        {
            Administración,
            Comercial,
            Presupuesto,
            Empleado
        }

        /// <summary>
        /// Indica si el usuario especificado esta bloqueado
        /// </summary>
        /// <param name="pUsuarioId"></param>
        /// <returns></returns>
        public static bool UsuarioEstaBloqueado(string pUsuarioId)
        {   
                MembershipUser _usuario = Membership.GetUser(pUsuarioId);
                return _usuario.IsLockedOut;
        }
        public static void DesbloquearUsuario(string pUsuarioId)
        {
            MembershipUser _usuario = Membership.GetUser(pUsuarioId);
            _usuario.UnlockUser();
        }
        /// <summary>
        /// Indica si el usuarioId existe en la base de datos de seguridad.
        /// </summary>
        /// <param name="pUsuarioId"></param>
        /// <returns></returns>
        public static bool ElUsuarioExiste(string pUsuarioId)
        {
            MembershipUser _usuario = Membership.GetUser(pUsuarioId);
            if (_usuario == null)
                return false;
            else
                return true;
        }
        public static bool InsertarUsuarioDeSeguridad(string pUsuarioId, string pContrasena)
        {
            if(ElUsuarioExiste(pUsuarioId) == true)
                throw new ArgumentException("El usuario ya existe en la base de datos");

            MembershipUser _usuario = Membership.CreateUser(pUsuarioId, pContrasena);
            if (_usuario != null)
                return true;
            else
                return false;
        }
        public static void EliminarUsuarioDeSeguridad(string pNombreUsuario)
        {
            if (Membership.DeleteUser(pNombreUsuario) == false)
                throw new ArgumentException("El usuario no se puede eliminar o no existe.");
        }
        public static void ReestablecerContrasena(string pUsuarioId, string pContrasena)
        {
            if (ElUsuarioExiste(pUsuarioId) == false)
                throw new ArgumentException("El usuario no existe en la base de datos");

            MembershipUser _usuario = Membership.GetUser(pUsuarioId);
            _usuario.ChangePassword(_usuario.ResetPassword(), pContrasena);
        }
        /// <summary>
        /// Devuelve si el usuario pertenece al rol indicado.
        /// </summary>
        /// <param name="pUsuarioId"></param>
        /// <param name="pRol"></param>
        /// <returns></returns>
        public static bool UsuarioPerteneceARol(string pUsuarioId, string pRol)
        {
            return Roles.IsUserInRole(pUsuarioId, pRol);
        }
        public static bool ValidarCredenciales(string pUsuario, string pContrasena)
        {
            if((pUsuario == "")
                || (pContrasena == ""))
                return false;
            
            return Membership.ValidateUser(pUsuario, pContrasena);
        }
    }
    /// <summary>
    /// Clase utilizada para la presentación y propiedades derivadas.
    /// </summary>
    public partial class ONEmpleado
    {
        public string ApellidoYNombre
        { 
            get 
            {
                string _aux = ", ";
                if ((Apellido == "") || (Nombre == ""))
                    _aux = "";
                return Apellido + _aux + Nombre;
            }
        }
        public string SectorNombre
        {
            get
            {
                if (Sector == null)
                    return "";
                else
                    return Sector.Nombre;
            }
            
        }
        public string StringUsuarioIdBloqueado
        {
            get
            {
                if (this.EstaBloqueado == true)
                    return "Si";
                else
                    return "No";
            }
        }
    }
    /// <summary>
    /// Clase base con la lógica de negocio
    /// </summary>
    [System.ComponentModel.DataObject]
    public partial class ONEmpleado
    {
        #region Atributos
        protected int _id;
        protected int _sectorId;
        protected string _usuarioId;
        protected string _contrasena;
        protected string _nombre;
        protected string _apellido;
        protected string _dni;
        protected string _cuit;
        protected string _telefonoFijo;
        protected string _telefonoMovil;
        protected string _domicilio;
        protected DateTime _fechaAlta;
        protected bool _estaActivo;    
        
        //Objetos asociados
        protected ONSector _sector;
        #endregion

        #region Propiedades
        public int ID
        {
            get
            {
                return _id;
            }
            set
            {
                _id = value;
            }
        }
        public int SectorId
        {
            get
            {
                return _sectorId;
            }
            set
            {
                _sectorId = value;
            }
        }
        public string UsuarioId
        {
            get { return _usuarioId; }
            set { _usuarioId = value; }
        }
        public string Contrasena
        {
            get { return _contrasena; }
            set { _contrasena = value; }
        }
        public string Nombre
        {
            get
            {
                return _nombre;
            }
            set
            {
                _nombre = value;
            }
        }
        public string Apellido
        {
            get
            {
                return _apellido;
            }
            set
            {
                _apellido = value;
            }
        }
        public string Dni
        {
            get
            {
                return _dni;
            }
            set
            {
                _dni = value;
            }
        }
        public string Cuit
        {
            get
            {
                return _cuit;
            }
            set
            {
                _cuit = value;
            }
        }
        public string TelefonoFijo
        {
            get
            {
                return _telefonoFijo;
            }
            set
            {
                _telefonoFijo = value;
            }
        }
        public string TelefonoMovil
        {
            get
            {
                return _telefonoMovil;
            }
            set
            {
                _telefonoMovil = value;
            }
        }
        public string Domicilio
        {
            get
            {
                return _domicilio;
            }
            set
            {
                _domicilio = value;
            }
        }
        public DateTime FechaAlta
        {
            get
            {
                return _fechaAlta;
            }
            set
            {
                _fechaAlta = value;
            }
        }
        public bool EstaActivo
        {
            get
            {
                return _estaActivo;
            }
            set
            {
                _estaActivo = value;
            }
        }
        //public string RolesSeguridad
        //{
        //    get
        //    {
        //        return "";
        //    }
        //}
        public bool EstaBloqueado
        {
            get
            {
                try
                {
                    return UsuarioEstaBloqueado(this.UsuarioId);
                }
                catch
                {
                    return true;
                }
            }
        }

        //Objetos asociados
        public ONSector Sector
        {
            get
            {
                if ((_sector != null)
                    && (_sector.ID == SectorId))
                    return _sector;

                _sector = ONSector.CrearSector(SectorId);
                return _sector;
            }
            set
            {
                _sector = value;
                if (value == null)
                    SectorId = -1;
                else
                    SectorId = value.ID;
            }
        }

        //Propiedades derivadas
        #endregion

        #region Interfase DAL
        //objeto de la capa DAL
        private static EmpleadoTableAdapter _empleadoAD;
        protected static EmpleadoTableAdapter Adaptador
        {
            get
            {
                if (_empleadoAD == null)
                    _empleadoAD = new EmpleadoTableAdapter();

                return _empleadoAD;
            }
        }
        protected static ONEmpleado ObtenerPorID(int pID)
        {
            ONEmpleado _empleado = null;
            _STG_DAL.EmpleadoDataTable _dt;

            // obtengo el Empleado por ID
            EmpleadoTableAdapter _adaptador = new EmpleadoTableAdapter(); // lo creo aca por que este es un metodo estatico
            
            _dt = _adaptador.ObtenerPorId(pID);

            // si tiene algo,
            if (_dt.Rows.Count > 0)
                _empleado = AsignarRowAObjeto((_STG_DAL.EmpleadoRow)_dt.Rows[0]);

            return _empleado;
        }
        protected static ONEmpleado AsignarRowAObjeto(_STG_DAL.EmpleadoRow pRow)
        {
            ONEmpleado _empleado = null;
            if (pRow != null)
            {
                _empleado = new ONEmpleado();
                _empleado.ID = pRow.ID;
                _empleado.Nombre = pRow.Nombre;
                _empleado.Apellido = pRow.Apellido;
                _empleado.Dni = pRow.DNI;
                _empleado.Cuit = pRow.CUIT;
                _empleado.TelefonoFijo = pRow.TelefonoFijo;
                _empleado.TelefonoMovil = pRow.TelefonoMovil;
                _empleado.Domicilio = pRow.Domicilio;
                _empleado.FechaAlta = pRow.FechaAlta;
                _empleado.EstaActivo = pRow.EstaActivo;
                _empleado.UsuarioId = pRow.UsuarioId;
                _empleado.SectorId = pRow.SectorId;
            }
            return _empleado;
        }
        protected ONEmpleado InsertarDAL(int pSectorId,string pUsuarioId,string pContrasena, string pNombre,string pApellido,string pDNI,string pCUIT,string pTelefonoFijo,string pTelefonoMovil,string pDomicilio,bool pEstaActivo)
        {
            if (InsertarUsuarioDeSeguridad(pUsuarioId, pContrasena) == false)
                throw new ArgumentException("El usuario ingresado ya existe en la base de datos.");

            ID = int.Parse(Adaptador.Insertar(pSectorId, pNombre, pApellido, pDNI, pCUIT, pTelefonoFijo, pTelefonoMovil, pDomicilio, DateTime.Now, pEstaActivo, pUsuarioId).ToString());
            return this;
        }
        protected bool ActualizarDAL(int pSectorId, string pUsuarioId, string pNombre, string pApellido, string pDNI, string pCUIT, string pTelefonoFijo, string pTelefonoMovil, string pDomicilio, DateTime pFechaAlta, bool pEstaActivo, int pId)
        {
            if (0 < Adaptador.Actualizar(pSectorId, pNombre, pApellido, pDNI, pCUIT, pTelefonoFijo, pTelefonoMovil, pDomicilio, pFechaAlta, pEstaActivo, pUsuarioId, pId))
                return true;
            else
                return false;
        }
        protected static ONEmpleadoColeccion AsignarEmpleadoTableAdapterAEmpleadoColeccion(_STG_DAL.EmpleadoDataTable pDataTable)
        {
            ONEmpleadoColeccion _empleados = new ONEmpleadoColeccion();
            ONEmpleado _empleado;

            if ((pDataTable != null)
                && (pDataTable.Rows.Count > 0))
            {
                foreach (_STG_DAL.EmpleadoRow _row in pDataTable.Rows)
                {
                    _empleado = AsignarRowAObjeto(_row);
                    if (_empleado != null)
                        _empleados.Add(_empleado);
                }
            }
            return _empleados;
        }

        public static ONEmpleadoColeccion ObtenerEmpleadosActivos()
        {
            return AsignarEmpleadoTableAdapterAEmpleadoColeccion(Adaptador.ObtenerEmpleados());
        }
        public static ONEmpleado ObtenerEmpleadoPorUsuarioID(string pUsuarioID)
        {
            ONEmpleado _empleado = new ONEmpleado();
            _STG_DAL.EmpleadoDataTable _dt;

            // obtengo el Empleado por ID
            EmpleadoTableAdapter _adaptador = new EmpleadoTableAdapter(); // lo creo aca por que este es un metodo estatico

            _dt = _adaptador.ObtenerEmpleadoPorUsuarioId(pUsuarioID);

            // si tiene algo,
            if (_dt.Rows.Count > 0)
                _empleado = AsignarRowAObjeto((_STG_DAL.EmpleadoRow)_dt.Rows[0]);

            return _empleado;
        }

        #endregion

        #region Métodos
        public ONEmpleado()
        {
            AsignarValoresIniciales();
        }

        public void AsignarValoresIniciales()
        {
            _id = -1;
            SectorId = -1;
            Nombre = "";
            Apellido = "";
            Dni = "";
            Cuit = "";
            TelefonoFijo = "";
            TelefonoMovil = "";
            Domicilio = "";
            FechaAlta = DateTime.Today;
            EstaActivo = true;
        }

        public static ONEmpleado CrearEmpleado()
        {
            ONEmpleado _empleado = new ONEmpleado();
            return _empleado;
        }
        public static ONEmpleado CrearEmpleado(int pID)
        {
            ONEmpleado _empleado = ObtenerPorID(pID);
            return _empleado;
        }
        public ONEmpleado Insertar()
        {
            return InsertarDAL(SectorId, UsuarioId, Contrasena, Nombre, Apellido, Dni, Cuit, TelefonoFijo, TelefonoMovil, Domicilio, EstaActivo);
        }
        public bool Actualizar()
        {
            return ActualizarDAL(SectorId, UsuarioId, Nombre, Apellido, Dni, Cuit, TelefonoFijo, TelefonoMovil, Domicilio, FechaAlta, EstaActivo, ID);
        }
        public static bool Eliminar(int pEmpleadoId)
        {
            if (Adaptador.Eliminar(pEmpleadoId) > 0)
            {
                //elimino el usuario de la base de datos.
                ONEmpleado _empleado = ONEmpleado.ObtenerPorID(pEmpleadoId);
                EliminarUsuarioDeSeguridad(_empleado.UsuarioId);
                return true;
            }
            else
                throw new ArgumentException("El empleado no existe.");
        }
        public void HabilitarAcceso()
        {
            DesbloquearUsuario(this.UsuarioId);
        }
        #endregion

        #region Metodos para datasource
        public void Actualizar(ONEmpleado pEmpleado)
        {
            if (pEmpleado != null)
                pEmpleado.Actualizar();
        }
        public ONEmpleado Insertar(ONEmpleado pEmpleado)
        {
            if (pEmpleado != null)
                return pEmpleado.Insertar();
            return null;
        }
        public void Eliminar(ONEmpleado pEmpleado)
        {
            ONEmpleado.Eliminar(pEmpleado.ID);
        }
        #endregion
    }
    [System.ComponentModel.DataObject]
    public class ONEmpleadoColeccion : System.Collections.CollectionBase
    {
        public void Add(ONEmpleado pEmpleado)
        {
            this.List.Add(pEmpleado);
        }
        public void AddUnico(ONEmpleado pEmpleado)
        {
            foreach (ONEmpleado _empleado in this)
                if (pEmpleado.ID == _empleado.ID)
                    return;
            this.List.Add(pEmpleado);
        }
        public void Remove(int index)
        {
            if (index <= Count - 1 || index >= 0)
            {
                this.List.RemoveAt(index);
            }
            else
            {
                throw new System.ArgumentException("Fuera de rango", "original");
            }
        }
        public void Remove(ONEmpleado pEmpleado)
        {
            for (int i = 0; i < this.Count; i++)
            {
                if (this[i].ID == pEmpleado.ID)
                {
                    Remove(i);
                    return;
                }

            }
        }
        public void EliminarEmpleado(ONEmpleado pEmpleado)
        {
            ONEmpleado.Eliminar(pEmpleado.ID);
        }
        public ONEmpleado this[int index]
        {
            get { return ((ONEmpleado)(this.List[index])); }
            set { this.List[index] = value; }
        }
        
        #region Metodos de colección
        
        #endregion
        #region Para datasource
        public void Insertar(ONEmpleado pEmpleado)
        {
            pEmpleado.Insertar(pEmpleado);
        }
        public static ONEmpleadoColeccion ObtenerTodo()
        {
            return ONEmpleado.ObtenerEmpleadosActivos();
        }
        #endregion
    }
    public class Rol
    {
        protected string _Descripcion;

        public string Descripcion
        {
            get
            {
                return _Descripcion;
            }
            set
            {
                _Descripcion = value;
            }
        }

        public RolColeccion ObtenerTodosLosRoles
        {
            get
            {
                RolColeccion _resultado = new RolColeccion();
                Rol _rol;
                string[] _roles = Roles.GetAllRoles();
                foreach (string _rolString in _roles)
                {
                    _rol = new Rol();
                    _rol.Descripcion = _rolString;
                    _resultado.Add(_rol);
                }
                return _resultado;
            }
        }
    }
    public class RolColeccion: System.Collections.CollectionBase
    {
        public void Add(Rol pRol)
        {
            this.List.Add(pRol);
        }

    }
}
